import java.util.*;

public class Main {

    //
    public static void main1(String[] args){
        Scanner in = new Scanner(System.in);
        char[] s = in.next().toCharArray();

        int sum = 0, count = 1, n = s.length;
        for(int i = 0; i < n - 1; i++){
            if(s[i] >= '0' && s[i] <= '9'){
                sum += (s[i] - '0') * count;
                count++;
            }
        }
        sum %= 11;

        if(sum == s[n - 1] - '0' || (sum == 10 && s[n - 1] == 'X')){
            System.out.println("Right");
        }else{
            s[n - 1] = sum == 10 ? 'X' : (char)(sum + '0');
            for(int i = 0; i < n; i++){
                System.out.print(s[i]);
            }
        }
    }

    //
    public static int N = 35;
    public static int x1, y1;
    public static int n , m;
    public static char[][] num = new char[N][N];
    public static int[][] dist = new int[N][N];

    public static int[] dx = {0,0,1,-1};
    public static int[] dy = {1,-1,0,0};

    public static void bfs(){
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                dist[i][j] = -1;
            }
        }

        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{x1, y1});
        dist[x1][y1] = 0;

        while(!queue.isEmpty()){
            int[] tmp = queue.poll();
            int a = tmp[0], b = tmp[1];
            for(int i = 0; i < 4; i++){
                int x = dx[i] + a, y = dy[i] + b;
                if(x >= 0 && x < n && y >= 0 && y < m && num[x][y] != '*' && dist[x][y] == -1){
                    dist[x][y] = dist[a][b] + 1;
                    if(num[x][y] != 'e'){
                        queue.add(new int[]{x, y});
                    }
                }
            }
        }
    }

    public static void main2(String[] args){
        Scanner in = new Scanner(System.in);
        n = in.nextInt(); m = in.nextInt();
        for(int i = 0; i < n; i++){
            char[] tmp = in.next().toCharArray();
            for(int j = 0; j < m; j++){
                num[i][j] = tmp[j];
                if(num[i][j] == 'k'){
                    x1 = i;
                    y1 = j;
                }
            }
        }

        bfs();

        int count = 0, ret = 1000;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(num[i][j] == 'e' && dist[i][j] != -1){
                    count++;
                    ret = Math.min(ret, dist[i][j]);
                }
            }
        }

        if(count == 0){
            System.out.println(-1);
        }else{
            System.out.println(count + " " + ret);
        }
    }

    //
//    public static int m, n;
//    public static int[] dx = {0,0,1,-1};
//    public static int[] dy = {1,-1,0,0};
    public static int[][] memo = new int[1010][1010];

    public int dfs(int[][] matrix, int i, int j){
        if(memo[i][j] != -1) { return memo[i][j];}

        int len = 1;
        for(int k = 0; k < 4; k++){
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j]){
                len = Math.max(len, 1 + dfs(matrix, x, y));
            }
        }

        memo[i][j] = len;
        return len;
    }

    public int solve (int[][] matrix) {
        m = matrix.length; n = matrix[0].length;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                memo[i][j] = -1;
            }
        }

        int ret = 1;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                ret = Math.max(ret, dfs(matrix, i, j));
            }
        }
        return ret;
    }

    //
//    int[] dx = {0,0,1,-1};
//    int[] dy = {1,-1,0,0};

    public int[][] floodFill(int[][] image, int sr, int sc, int color) {
        int prev = image[sr][sc];
        if(prev == color) { return image;}
        int m = image.length, n = image[0].length;

        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{sr, sc});

        while(!queue.isEmpty()){
            int[] tmp = queue.poll();
            int a = tmp[0], b = tmp[1];
            image[a][b] = color;
            for(int i = 0; i < 4; i++){
                int x = dx[i] + a, y = dy[i] + b;
                if(x >= 0 && x < m && y >= 0 && y < n && image[x][y] == prev){
                    queue.add(new int[]{x, y});
                }
            }
        }
        return image;
    }

    //
//    int m, n;
//    int[] dx = {0,0,1,-1};
//    int[] dy = {1,-1,0,0};
     boolean[][] vis = new boolean[310][310];

    public void dfs(char[][] grid, int i, int j){
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i, j});
        vis[i][j] = true;

        while(!queue.isEmpty()){
            int[] t = queue.poll();
            int a = t[0], b = t[1];
            for(int k = 0; k < 4; k++){
                int x = dx[k] + a, y = dy[k] + b;
                if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1' && !vis[x][y]){
                    queue.add(new int[]{x, y});
                    vis[x][y] = true;
                }
            }
        }
    }

    public int numIslands(char[][] grid) {
        m = grid.length; n = grid[0].length;
        int ret = 0;

        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == '1' && !vis[i][j]){
                    ret++;
                    dfs(grid, i, j);
                }
            }
        }
        return ret;
    }

    //
//    int m, n;
//    int[] dx = {0,0,1,-1};
//    int[] dy = {1,-1,0,0};
//    boolean[][] vis = new boolean[80][80];

    public int dfs(int[][] grid, int i, int j){
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i, j});
        vis[i][j] = true;
        int ret = 1;

        while(!queue.isEmpty()){
            int[] t = queue.poll();
            int a = t[0], b = t[1];
            for(int k = 0; k < 4; k++){
                int x = dx[k] + a, y = dy[k] + b;
                if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 && !vis[x][y]){
                    ret++;
                    queue.add(new int[]{x, y});
                    vis[x][y] = true;
                }
            }
        }
        return ret;
    }

    public int maxAreaOfIsland(int[][] grid) {
        m = grid.length; n = grid[0].length;
        int ret = 0;

        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 1 && !vis[i][j]){
                    ret = Math.max(ret, dfs(grid, i, j));
                }
            }
        }
        return ret;
    }
}
